home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / jovept1.arc / IO.C < prev   
Text File  |  1985-05-30  |  7KB  |  400 lines
  1. /* io.c */
  2.  
  3. /* JOVE/MSDOS. K. Mitchum 1/85 */
  4. /* Modifications for personal use only. */
  5. /* original code J. Payne LSRHS 5/83 */
  6. /* Ken Mitchum */
  7. /* University of Pittsburgh */
  8. /* Decision Systems Laboratory */
  9.  
  10. /*
  11.    Jonathan Payne at Lincoln-Sudbury Regional High School 5-25-83
  12.   
  13.    Commands to read/write files/regions.  */
  14.  
  15. #include "jove.h"
  16. #include "term.h"
  17. #include "files.h"
  18.  
  19.  
  20. #ifdef UNIX
  21. #include <sys/types.h>
  22. #include <sys/stat.h>
  23. #else
  24. #include "stat.h"
  25. #endif
  26.  
  27. extern int EndWNewline;
  28.  
  29. int    ninbuf;
  30.  
  31. static char *werror    = "Write error";
  32. static long count = 0;
  33. static int nlines = 0;
  34. static char iobuff[LBSIZE], *nextip;
  35.  
  36.  
  37. IOclose()
  38. {
  39.     if (io > 0)
  40.         ignore(close(io)), io = -1;
  41.     nextip = iobuff;
  42.     ninbuf = 0;
  43. }
  44.  
  45. /* This reads a line from the input file into buf. */
  46.  
  47. getfline(buf)
  48. char    *buf;
  49. {
  50.     register int    c;
  51.     register char    *lp,
  52.             *fp;
  53.  
  54.     lp = buf;
  55.     *lp = '\0';
  56.     fp = nextip;
  57.     do {
  58.         if (--ninbuf < 0) {
  59.             ninbuf = read(io, iobuff, LBSIZE) - 1;
  60.             fp = iobuff;
  61.             if (ninbuf < 0) {
  62.                 *lp = '\0';
  63.                 IOclose();
  64.                 return EOF;
  65.             }
  66.         }
  67.         c = *fp++;
  68.         if (c == '\0')
  69.             continue;
  70.         if (lp >= &buf[LBSIZE - 1]) {
  71.             message("Line to long...");
  72.             redisplay();
  73.             IOclose();
  74.             return EOF;
  75.         }
  76.  
  77.         *lp++ = c;
  78.         count++;
  79.     } while (c != '\n');
  80.     *--lp = 0;
  81.     nextip = fp;
  82.     return 0;
  83. }
  84.  
  85. /* Write the region from line1/char1 to line2/char2 to the open
  86.    fildes `io'.  */
  87.  
  88.  
  89. putreg(line1, char1, line2, char2)
  90. LINE    *line1,
  91.     *line2;
  92. {
  93.     int n;
  94.     register char *fp, *lp;
  95.     register int    nib;
  96.  
  97.     count = nlines = 0;
  98.     nib = 512;
  99.     fp = iobuff;
  100.     lsave();    /* Need this! */
  101.  
  102.     while (line1 != line2->l_next) {
  103.         lp = getline(line1->l_dline, linebuf) + char1;
  104.         if (line1 == line2)
  105.             linebuf[char2] = '\0';
  106.         for (;;) {
  107.             if (--nib < 0) {
  108.                 n = fp - iobuff;
  109.                 if (write(io, iobuff, n) != n)
  110.                     goto werror;
  111.                 nib = 511;
  112.                 count += n;
  113.                 fp = iobuff;
  114.             }
  115.             if ((*fp++ = *lp++) == 0) {
  116.                 if (line1 != line2) {
  117.                     nlines++;
  118.                     fp[-1] = '\n';
  119.                 } else
  120.                     fp--;    /* Don't write the NULL!! */
  121.                 break;
  122.             }
  123.         }
  124.         line1 = line1->l_next;
  125.         char1 = 0;
  126.     }
  127.     n = fp - iobuff;
  128.  
  129.     if (write(io, iobuff, n) != n)
  130.         goto werror;
  131.     count += n;
  132.     getDOT();        /* What ever was in linebuf */
  133.     IOclose();
  134.     return;
  135. werror:
  136.     error(werror);
  137.     /* NOTREACHED */
  138. }
  139.  
  140. char *
  141. IOerr(err, file)
  142. char    *err, *file;
  143. {
  144.     return sprint("Couldn't %s \"%s\"", err, file);
  145. }
  146.  
  147. read_file(file)
  148. char    *file;
  149. {
  150.     BUFLOC    save;
  151.  
  152.     setcmode();
  153.  
  154.     io = open(file, READMODE);
  155.     if (io == -1) {
  156.         curbuf->b_ino = -1;
  157.         s_mess(IOerr("open", file));
  158.         return;
  159.     }
  160.     DOTsave(&save);
  161.     set_ino(curbuf);
  162.     dofread(file);
  163.     SetDot(&save);
  164.     getDOT();
  165.     IOclose();
  166. }
  167.  
  168. FileMess(file, lines, chars)
  169. char    *file;
  170. long    chars;
  171. {
  172.     s_mess("\"%s\" %d lines %D characters", file, lines, chars);
  173. }
  174.  
  175. dofread(file)
  176. char    *file;
  177. {
  178.     char    end[LBSIZE];
  179.     int    xeof = 0;
  180.  
  181.     lsave();
  182.     nlines = 0;
  183.     count = 0L;
  184.     s_mess("\"%s\"", file);
  185.  
  186.     UpdateMesg();
  187.     ignore(getline(curline->l_dline, end));
  188.     strcpy(genbuf, end);
  189.     strcpy(end, &end[curchar]);
  190.     if ((xeof = getfline(linebuf)) == 0)
  191.         linecopy(genbuf, curchar, linebuf);
  192.     curline->l_dline = putline(genbuf);
  193.     if (!xeof) do {
  194.         xeof = getfline(linebuf);
  195.         nlines++;
  196.         curline = listput(curbuf, curline);
  197.         curline->l_dline = putline(linebuf) | DIRTY;
  198.     } while (!xeof);
  199.     linecopy(linebuf, (curchar = strlen(linebuf)), end);
  200.     curline->l_dline = putline(linebuf);
  201.     FileMess(file, nlines, count);
  202. }
  203.  
  204. bufname(bp)
  205. BUFFER    *bp;
  206. {
  207.     char    tmp[100],
  208.         tmp1[100],
  209.         *cp;
  210.     int    try = 1;
  211.  
  212.     if ((cp = bp->b_fname) == 0)
  213.         complain("No file name");
  214.         
  215.     if (*cp == '.')
  216.         ++cp;
  217.     strcpy(tmp, cp);
  218.     cp = rindex(tmp, '/');
  219.     if (cp)
  220.         strncpy(tmp, &cp[1], sizeof tmp);
  221.  
  222.     strcpy(tmp1, tmp);
  223.     while (buf_exists(tmp)) {
  224.         ignore(sprintf(tmp, "%s<%d>", tmp1, try));
  225.         try++;
  226.     }
  227.     setbname(bp, tmp);
  228. }
  229.  
  230. SaveFile()
  231. {
  232.     if (IsModified(curbuf)) {
  233.         SetUnmodified(curbuf);
  234.         file_write(curbuf->b_fname, 0);
  235.     } else
  236.         s_mess("No changes need be written");
  237. }
  238.  
  239. filemunge(fname)
  240. char    *fname;
  241. {
  242.     struct stat    stbuf;
  243.  
  244.     if (stat(fname, &stbuf))
  245.         return;
  246. #ifdef UNIX
  247.     if (stbuf.st_ino != curbuf->b_ino && (stbuf.st_mode & S_IFMT) != S_IFCHR) 
  248. #else
  249.     if (stbuf.st_ino != curbuf->b_ino)
  250. #endif
  251.         confirm("\"%s\" already exist; are you sure? ", fname);
  252. }
  253.  
  254. WrtReg()
  255. {
  256.     DoWriteReg(0);
  257. }
  258.  
  259. AppReg()
  260. {
  261.     DoWriteReg(1);
  262. }
  263.  
  264. DoWriteReg(app)
  265. {
  266.     char    fname[100];
  267.     MARK    *mp = CurMark();
  268.  
  269.     /* Won't get here if there isn't a mark */
  270.     strcpy(fname, ask((char *)0, FuncName()));
  271.  
  272.     if (!app)
  273.         filemunge(fname);
  274.     if (app) {
  275.         io = open(fname, WRITEMODE);    /* Writing */
  276.         if (io == -1)
  277.             io = creat(fname, CREATMODE);
  278.         else
  279.             dolseek(io, 0L, 2);
  280.     } else 
  281.         io = creat(fname, CREATMODE);
  282.     if (io == -1)
  283.         complain(IOerr("create", fname));
  284.  
  285.     s_mess("\"%s\"", fname);
  286.     UpdateMesg();            /* Update mesg line */
  287.     if (inorder(mp->m_line, mp->m_char, curline, curchar))
  288.         putreg(mp->m_line, mp->m_char, curline, curchar);
  289.     else
  290.         putreg(curline, curchar, mp->m_line, mp->m_char);
  291.     FileMess(fname, nlines, count);
  292.     IOclose();
  293. }
  294.  
  295. WriteFile()
  296. {
  297.     char    *fname,
  298.         fnamebuf[100];
  299.  
  300.     fname = ask(curbuf->b_fname, FuncName());
  301.     strncpy(fnamebuf, fname, sizeof fnamebuf);
  302.  
  303.     filemunge(fnamebuf);
  304.     setfname(curbuf, fnamebuf);
  305.     set_ino(curbuf);
  306.     file_write(curbuf->b_fname, exp_p);
  307.     SetUnmodified(curbuf);
  308. }
  309.  
  310. file_write(fname, app)
  311. char    *fname;
  312. {
  313.     if (fname == 0 || *fname == '\0')
  314.         complain("I need a file name");
  315.  
  316.     io = -1;
  317.     if (app) {
  318.         io = open(fname, WRITEMODE);    /* Writing */
  319.         if (io == -1)
  320.             io = creat(fname, CREATMODE);
  321.         else
  322.             dolseek(io, 0L, 2);
  323.     } else 
  324.         io = creat(fname, CREATMODE);
  325.     if (io == -1)
  326.         complain(IOerr("create", fname));
  327.  
  328.     s_mess("\"%s\"", fname);
  329.     UpdateMesg();        /* Update mesg line */
  330.     if (EndWNewline) {    /* Make sure file ends with a newline */
  331.         BUFLOC    save;
  332.  
  333.         DOTsave(&save);
  334.         Eof();
  335.         if (length(curline))    /* Not a blank line */
  336.             DoTimes(LineInsert, 1);    /* Make it blank */
  337.         SetDot(&save);
  338.     }        
  339.     putreg(curbuf->b_zero, 0, curbuf->b_dol, length(curbuf->b_dol));
  340.     FileMess(fname, nlines, count);
  341.     IOclose();
  342. }
  343.  
  344. initlist(bp)
  345. BUFFER    *bp;
  346. {
  347.     lfreelist(bp->b_zero);
  348.     ignore(listput(bp, (LINE *) 0));        /* First line in buffer */
  349.     
  350.     bp->b_dot->l_dline = putline("") | DIRTY;
  351.     bp->b_char = 0;
  352.     AllMarkSet(bp, bp->b_dot, 0);
  353.     if (bp == curbuf)
  354.         getDOT();
  355.     initwinds(bp);
  356. }
  357.  
  358. setcmode()
  359. {
  360.     int    len = curbuf->b_fname ? strlen(curbuf->b_fname) : 0;
  361.     
  362.     if (len < 2)
  363.         return;
  364.     if ((curbuf->b_fname[len - 1] | 0x20)== 'c' && curbuf->b_fname[len - 2] == '.')
  365.         OnFlag(globflags, CMODE);
  366.         OnFlag(globflags, MATCHING);
  367. }
  368.  
  369. ReadFile()
  370. {
  371.     char    *fname;
  372.  
  373.     if (IsModified(curbuf))
  374.         confirm("%s modified, shall I read anyway? ", filename(curbuf));
  375.  
  376.     fname = ask(curbuf->b_fname, FuncName());
  377.     SetUnmodified(curbuf);
  378.     setfname(curbuf, fname);
  379.     initlist(curbuf);
  380.     read_file(curbuf->b_fname);
  381. }
  382.  
  383. InsFile()
  384. {
  385.     char    *fname;
  386.  
  387.     fname = ask(curbuf->b_fname, FuncName());
  388.     read_file(fname);
  389.     SetModified(curbuf);
  390. }
  391.  
  392. dolseek(fd, offset, whence)
  393. long    offset;
  394. {
  395.     if (lseek(fd, offset, whence) == -1)
  396.         complain("lseek failed");
  397. }
  398.  
  399. /* end */
  400.